import { formatApiUrl } from '../settings/settings.js'
import { executeTool, toolDescriptions } from '../tools/tools.js'
import { debug } from '../utils/debug.js'

// 请求权限
export async function requestPermissions(debug) {
  try {
    const requiredPermissions = {
      permissions: ['tabs', 'bookmarks', 'system.cpu', 'system.memory'],
    }

    const currentPermissions = await chrome.permissions.getAll()
    debug('当前权限:', currentPermissions)

    const result = await chrome.permissions.request(requiredPermissions)
    debug('权限请求结果:', result)

    if (result) {
      const finalPermissions = await chrome.permissions.getAll()
      debug('授权后的权限:', finalPermissions)
    }

    return result
  } catch (error) {
    debug('请求权限时出错:', error)
    return false
  }
}

// 获取浏览器信息
export async function getBrowserInfo(debug) {
  try {
    debug('开始获取浏览器信息...')
    const info = {
      currentTab: null,
      systemInfo: {},
      browserInfo: navigator.userAgent,
      recentTabs: [],
      recentBookmarks: [],
    }

    // 获取当前标签页信息
    try {
      debug('正在获取当前标签页...')
      const queryOptions = { active: true, currentWindow: true }
      const [tab] = await chrome.tabs.query(queryOptions)
      if (
        tab?.url &&
        tab?.title &&
        !tab.url.startsWith('chrome://') &&
        !tab.url.startsWith('edge://')
      ) {
        info.currentTab = {
          url: tab.url,
          title: tab.title,
          html: '',
        }

        // 通过后台脚本获取页面内容
        try {
          const response = await new Promise((resolve, reject) => {
            chrome.runtime.sendMessage(
              { action: 'getPageContent' },
              (response) => {
                if (chrome.runtime.lastError) {
                  reject(chrome.runtime.lastError)
                } else {
                  resolve(response)
                }
              }
            )
          })

          if (response && response.content) {
            const parser = new DOMParser()
            const doc = parser.parseFromString(response.content, 'text/html')
            const article = new Readability(doc).parse()

            info.currentTab.summary = {
              title: article?.title || doc.title,
              text:
                article?.textContent
                  ?.replace(/\s+/g, ' ')
                  .replace(/[\r\n]+/g, ' ')
                  .replace(/\s{2,}/g, ' ')
                  .trim()
                  .substring(0, 2000) || '',
              images: article?.content
                ? Array.from(
                    new DOMParser()
                      .parseFromString(article.content, 'text/html')
                      .querySelectorAll('img')
                  )
                    .map((img) => ({
                      src: img.src,
                      alt: img.alt,
                    }))
                    .slice(0, 5)
                : [],
            }
            debug('解析后的页面内容:', info.currentTab.summary)
          } else {
            throw new Error(response.error || '无法获取页面内容')
          }
        } catch (e) {
          debug('获取页面内容失败:', e)
        }

        debug('当前标签页信息:', {
          url: info.currentTab.url,
          title: info.currentTab.title,
          htmlLength: info.currentTab.html.length,
        })
      }
    } catch (e) {
      debug('获取当前标签页失败:', e)
    }

    // 获取最近的标签页
    try {
      debug('正在获取所有标签页...')
      const allTabs = await chrome.tabs.query({})
      info.recentTabs = allTabs
        .filter((tab) => tab?.url && tab?.title)
        .map((tab) => ({
          url: tab.url,
          title: tab.title,
        }))
        .slice(0, 5)
      debug('获取到的标签页数量:', info.recentTabs.length)
    } catch (e) {
      debug('获取标签页列表失败:', e)
    }

    // 获取书签
    if (chrome.bookmarks) {
      try {
        debug('正在获取书签...')
        const bookmarks = await chrome.bookmarks.getRecent(5)
        if (Array.isArray(bookmarks)) {
          info.recentBookmarks = bookmarks.filter((b) => b?.title)
          debug('获取到的书签数量:', info.recentBookmarks.length)
        }
      } catch (e) {
        debug('获取书签失败:', e)
      }
    } else {
      debug('书签API不可用')
    }

    // 获取系统信息
    if (chrome.system) {
      try {
        debug('正在获取系统信息...')
        if (chrome.system.cpu) {
          info.systemInfo.cpu = await chrome.system.cpu.getInfo()
          debug('CPU信息:', info.systemInfo.cpu)
        }
        if (chrome.system.memory) {
          info.systemInfo.memory = await chrome.system.memory.getInfo()
          debug('内存信息:', info.systemInfo.memory)
        }
      } catch (e) {
        debug('获取系统信息失败:', e)
      }
    } else {
      debug('系统API不可用')
    }

    debug('所有信息获取完成')
    return info
  } catch (error) {
    debug('获取浏览器信息时出错:', error)
    return null
  }
}

// 发送消息
export async function sendMessage(message, debug, appendMessage) {
  try {
    // 检查是否是工具调用
    if (message.startsWith('<') && message.endsWith('>')) {
      try {
        const result = await executeTool(message, debug)
        appendMessage(result, false)
      } catch (error) {
        appendMessage(`工具执行失败: ${error.message}`, false)
      }
      return
    }

    debug('正在获取设置...')
    const settings = await chrome.storage.local.get(['apiUrl', 'apiKey'])
    debug('获取到的原始设置:', settings)

    const formattedUrl = formatApiUrl(settings.apiUrl)
    if (!formattedUrl || !settings.apiKey) {
      debug('API设置未完成')
      alert('请先配置API设置')
      return
    }

    appendMessage(message, true)

    debug('正在获取浏览器信息...')
    const browserInfo = await getBrowserInfo(debug)

    if (!browserInfo) {
      appendMessage('获取浏览器信息失败，但仍将继续对话', false)
    }

    debug('获取到的浏览器信息:', browserInfo)

    // 使用从tools.js导入的工具列表

    const toolsPrompt = toolDescriptions
      .map(
        (tool, index) => `${index + 1}. ${tool.description}:\n${tool.example}`
      )
      .join('\n\n')

    const systemPrompt = `你是一个能够访问浏览器API的AI助手。以下是当前浏览器的信息：
当前页面: ${browserInfo?.currentTab?.title || '未知'} (${
      browserInfo?.currentTab?.url || '未知'
    })
页面内容: ${browserInfo?.currentTab?.summary?.text || '无法获取页面内容'}
最近打开的标签页: ${
      browserInfo?.recentTabs
        ?.map((tab) => `\n- ${tab.title} (${tab.url})`)
        .join('') || '无'
    }
最近的书签: ${
      browserInfo?.recentBookmarks?.map((b) => b.title).join(', ') || '无'
    }

你可以根据这些信息来协助用户。用户问题是: ${message}

如果你需要执行某些操作，可以使用以下工具：

${toolsPrompt}

当需要调用工具时，请直接返回工具调用的XML格式，不要包含其他解释或说明。`

    const requestBody = {
      model: 'gpt-3.5-turbo',
      messages: [
        {
          role: 'system',
          content: systemPrompt,
        },
        {
          role: 'user',
          content: message,
        },
      ],
    }

    debug('准备发送请求，系统提示词:', systemPrompt)
    console.log('系统提示词内容:', systemPrompt)
    debug('完整请求内容:', requestBody)

    debug('准备发送请求到:', formattedUrl)
    const response = await fetch(formattedUrl, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        Authorization: `Bearer ${settings.apiKey}`,
      },
      body: JSON.stringify(requestBody),
    })

    debug('收到响应状态:', response.status)
    const data = await response.json()
    debug('收到响应数据:', data)

    if (data.code && data.code !== 0) {
      throw new Error(data.message || '服务器返回错误')
    }

    if (!response.ok) {
      throw new Error(`HTTP错误: ${response.status}`)
    }

    if (data.choices && data.choices[0]?.message?.content) {
      const aiResponse = data.choices[0].message.content
      debug('AI响应内容:', aiResponse)

      // 检查是否是工具调用
      if (aiResponse.startsWith('<') && aiResponse.endsWith('>')) {
        try {
          const result = await executeTool(aiResponse, debug)
          appendMessage(result, false)
        } catch (error) {
          appendMessage(`工具执行失败: ${error.message}`, false)
        }
      } else {
        appendMessage(aiResponse, false)
      }
    } else if (data.data?.choices && data.data.choices[0]?.message?.content) {
      const aiResponse = data.data.choices[0].message.content
      debug('AI响应内容:', aiResponse)

      // 检查是否是工具调用
      if (aiResponse.startsWith('<') && aiResponse.endsWith('>')) {
        try {
          const result = await executeTool(aiResponse)
          appendMessage(result, false)
        } catch (error) {
          appendMessage(`工具执行失败: ${error.message}`, false)
        }
      } else {
        appendMessage(aiResponse, false)
      }
    } else {
      throw new Error('响应格式不正确')
    }
  } catch (error) {
    debug('发送消息时出错:', error)
    appendMessage(`发生错误: ${error.message}`, false)
  }
}
